home *** CD-ROM | disk | FTP | other *** search
/ AOL File Library: 2,801 to 2,900 / aol-file-protocol-4400-2801-to-2900.zip / AOLDLs / C++ Files Library / Linked List Template Classes / Linked Lists Ä.sit / Linked Lists ƒ / source code / LinkedLists.cp next >
Text File  |  1995-03-03  |  7KB  |  283 lines
  1. #include "LinkedLists.h"
  2.  
  3. /***************************************************
  4.  
  5.     SlimListClass: Simple Pop and Push Features
  6.     
  7. ***************************************************/
  8.  
  9. template <class itemRecord> Boolean SlimListClass<itemRecord>::Push(itemRecord &theItem)
  10. {
  11.     ListItem<itemRecord> *newItem;
  12.     
  13.     newItem=new ListItem<itemRecord>;
  14.     newItem->item=theItem;
  15.     
  16.     if (newItem) {
  17.         newItem->next=theList;
  18.         theList=newItem;            //    theList variable always points to the top of the stack
  19.         return 1;
  20.     }
  21.     
  22.     return 0;
  23. }
  24.  
  25. template <class itemRecord> itemRecord SlimListClass<itemRecord>::Pop()
  26. {
  27.     if (theList) {
  28.         itemRecord thisItem=theList->item;
  29.         ListItem<itemRecord> *temp=theList->next;
  30.         
  31.         delete theList;
  32.         theList=temp;
  33.         
  34.         return thisItem;
  35.     }
  36.     
  37.     return theList->item;
  38. }
  39.  
  40. template <class itemRecord> void SlimListClass<itemRecord>::DeleteAll()
  41. {
  42.     ListItem<itemRecord>    *temp=nil;
  43.     
  44.     if (theList) {
  45.         temp=theList->next;
  46.         delete theList;
  47.         theList=temp;
  48.     }
  49.     
  50.     while (temp) {
  51.         temp=theList->next;
  52.         delete theList;
  53.         theList=temp;
  54.     }
  55.         
  56. }
  57.  
  58. /***************************************************
  59.  
  60.     SlimPlusClass: Adds Item Retrieval
  61.     
  62. ***************************************************/
  63.  
  64. template <class itemRecord, class comparisonObject> Boolean SlimPlusClass<itemRecord, comparisonObject>::ItemInList(itemRecord &theItem)
  65. {
  66.     ListItem<itemRecord>    *top;
  67.     
  68.     top=theList;
  69.     
  70.     if (theList->item==theItem)
  71.         return 1;
  72.     
  73.     while ((theList=theList->next)!=nil)
  74.         if (theList->item==theItem) {
  75.             theList=top;                        //    Restore theList var to the stack top address
  76.             return 1;
  77.         }
  78.     
  79.     theList=top;                                //    Restore theList var to the stack top address
  80.     return 0;
  81. }
  82.  
  83. template <class itemRecord, class comparisonObject> Boolean SlimPlusClass<itemRecord, comparisonObject>::XInList(comparisonObject theObject, itemRecord * &theItem)
  84. {
  85.     ListItem<itemRecord>    *top;
  86.     
  87.     top=theList;
  88.     
  89.     if (theList) {
  90.         if (theList->item==theObject) {
  91.             theItem=&(theList->item);            //    Set theItem to the address of the item's address
  92.             return 1;
  93.         }
  94.         else 
  95.             while ((theList=theList->next)!=nil) {
  96.                 if (theList->item==theObject) {
  97.                     theItem=&(theList->item);    //    Set theItem to the address of the item's address
  98.                     theList=top;                //    Restore theList var to the stack top address
  99.                     return 1;
  100.                 }
  101.             }
  102.     }
  103.     
  104.     theList=top;                                //    Restore theList var to the stack top address
  105.     
  106.     return 0;
  107. }
  108.  
  109.  
  110. /***************************************************
  111.  
  112.     ListClass : Full-Featured List Class
  113.     
  114. ***************************************************/
  115.  
  116.  
  117. template <class itemRecord> Boolean ListClass<itemRecord>::AddSort(itemRecord &theItem)
  118. {
  119.     ListItem<itemRecord> *newItem, *tempItem;
  120.     
  121.     placeHolder=newItem=new ListItem<itemRecord>;
  122.     
  123.     if (newItem) {
  124.         numberOfItems++;
  125.         newItem->item=theItem;
  126.     
  127.         ListItem<itemRecord>    *tempItem;
  128.                 
  129.         if (stackTop) {                            //    If stackTop is not nil, a stack is present
  130.         
  131.             if (theItem<stackTop->item) {        //    Set newItem->next to stackTop if it's less and
  132.                 newItem->next=stackTop;            //    set stackTop to newItem 
  133.                 stackTop=newItem;
  134.             }
  135.             
  136.             else {
  137.                 tempItem=stackTop;                //     Otherwise, put insert it in first spot it's less
  138.                                                 //    than an other item
  139.                 while (theItem>tempItem->next->item && tempItem->next)
  140.                     tempItem=tempItem->next;
  141.                 
  142.                 newItem->next=tempItem->next;
  143.                 tempItem->next=newItem;
  144.             }
  145.         }
  146.         
  147.         else {                                    //    Stack is created, set stackTop to newItem
  148.             stackTop=newItem;
  149.             newItem->next=nil;
  150.         }
  151.     return (1);
  152.     }
  153.     
  154.     return (0);
  155. }
  156.  
  157. template <class itemRecord> Boolean ListClass<itemRecord>::Add(itemRecord &theItem)
  158. {
  159.     ListItem<itemRecord> *newItem, *tempItem;
  160.     
  161.     placeHolder=newItem=new ListItem<itemRecord>;
  162.     
  163.     if (newItem) {
  164.         numberOfItems++;
  165.         newItem->item=theItem;
  166.         
  167.         if (stackTop) {                            //    Go through whole list until end is found, add
  168.             tempItem=stackTop;                    //    newItem to the end
  169.             while (tempItem->next)
  170.                 tempItem=tempItem->next;
  171.             
  172.             tempItem->next=newItem;
  173.         }
  174.         
  175.         else
  176.             stackTop=newItem;
  177.             
  178.         newItem->next=nil;                        //    Set newItem->next to nil, connotating end of list
  179.         return 1;
  180.     }
  181.     
  182.     return 0;
  183. }    
  184.  
  185. template <class itemRecord> Boolean ListClass<itemRecord>::Push(itemRecord &theItem)
  186. {
  187.     ListItem<itemRecord> *newItem;
  188.     
  189.     placeHolder=newItem=new ListItem<itemRecord>;
  190.     
  191.     if (newItem) {                        //    Essentially, this is the same as SlimListClasses,
  192.         numberOfItems++;                //    except that it updates the placeHolder var and the
  193.         newItem->item=theItem;            //    numberOfItems var
  194.         newItem->next=stackTop;
  195.         stackTop=newItem;
  196.         return 1;
  197.     }
  198.     
  199.     return 0;
  200. }
  201.  
  202. template <class itemRecord> itemRecord ListClass<itemRecord>::Pop()
  203. {
  204.     itemRecord    theItem;
  205.     ListItem<itemRecord> *temp=stackTop;
  206.     
  207.     theItem=stackTop->item;
  208.     placeHolder=stackTop=stackTop->next;
  209.     delete temp;
  210.     numberOfItems--;
  211.     return theItem;
  212. }
  213.  
  214. template <class itemRecord> void ListClass<itemRecord>::Delete(itemRecord theItem)
  215. {
  216.     ListItem<itemRecord>    *tempItem=stackTop;
  217.     
  218.     if (tempItem->item==theItem) {
  219.         placeHolder=stackTop=stackTop->next;
  220.         delete tempItem;
  221.         numberOfItems--;
  222.     }
  223.     
  224.     else {
  225.     
  226.         while (tempItem->next->item!=theItem && tempItem)
  227.             tempItem=tempItem->next;
  228.             
  229.         if (tempItem) {
  230.             ListItem<itemRecord>    *oldItem=tempItem->next;
  231.             
  232.             placeHolder=tempItem->next=tempItem->next->next;
  233.             delete oldItem;
  234.             numberOfItems--;
  235.         }
  236.     }
  237.     
  238. }
  239.         
  240. template <class itemRecord> void ListClass<itemRecord>::DeleteAll()
  241. {
  242.     ListItem<itemRecord>    *temp=stackTop;
  243.     
  244.     while (temp) {                    //    Essentially the same as the SlimListClass DeleteAll
  245.         temp=stackTop->next;
  246.         delete stackTop;
  247.         stackTop=temp;
  248.     }
  249.     numberOfItems=0;
  250.     placeHolder=stackTop;
  251. }
  252.  
  253. template <class itemRecord> ListItem<itemRecord> *ListClass<itemRecord>::GetPlaceItem(itemRecord * &theItem)
  254. {
  255.     if (placeHolder)
  256.         theItem=&(placeHolder->item); 
  257.     return placeHolder;
  258. }
  259.  
  260. template <class itemRecord> ListItem<itemRecord> *ListClass<itemRecord>::GetNextItem(itemRecord * &theItem)
  261. {
  262.     if (placeHolder)                    //    Check to make sure placeHolder is valid address
  263.         placeHolder=placeHolder->next; 
  264.     if (placeHolder)                     //    Check to make sure it still is, after pointing to the next
  265.         theItem=&(placeHolder->item);     //    If everything checks out, set second parameter to address
  266.     return placeHolder;                    //    of placeHolder's item
  267. }
  268.  
  269. template <class itemRecord> Boolean ListClass<itemRecord>::GetItemX(short itemNumber, itemRecord * &theItem)
  270. {
  271.     ListItem<itemRecord>    *temp=stackTop;
  272.     short n=1;
  273.  
  274.     if (itemNumber>numberOfItems)
  275.         return 0;
  276.     
  277.     while (n++!=itemNumber)
  278.         temp=temp->next;
  279.     
  280.     theItem=&(temp->item);
  281.     
  282.     return 1;
  283. }